#include<iostream>
#include<string>
#include<pthread.h>
#include<unistd.h>
#include <functional>
namespace ThreadMoudle
{
    
    using func_t=std::function<void(const std::string &)>;
    class Thread
    {
        public:
        void Excute()
        {
  
            _isrunning=true;
            _func(_name);
            _isrunning=false;

        }
        public:
            Thread(const std::string &name,func_t func):_name(name),_func(func)
            {
    
            }
            static void * ThreadRoutine(void * args)//这里为什么要加static：原因：
                                                    //只是使用函数的话由于定义的类内函数参数隐含一个参数this指针，
                                                    //所以和phthread_create函数的参数类型不同
                                                    //解决方法：
                                                    //定义成静态函数这里的这个函数 就属于类本身而不属于对象
            {
                Thread *self=static_cast<Thread*>(args);
                self->Excute();
                return nullptr;

            }
            bool Start()
            {
                int n=::pthread_create(&_tid,nullptr,ThreadRoutine,this);
                if(n!=0)return false;
                return true;
            }
            std::string Status() 
            {
                if(_isrunning)return "running";
                else return "sleep";
            }
            void Stop()
            {
                if(_isrunning)
                {
                    ::pthread_cancel(_tid);
                    _isrunning=false;
               
                }
            }
            void Join()
            {
                ::pthread_join(_tid,nullptr);
                std::cout<<_name<<"Joined"<<std::endl;
            }
            std::string Name()
            {
                return _name;
            }
            ~Thread()
            {

            }
        private:
        std::string _name;
        pthread_t _tid;
        bool _isrunning;
        func_t _func; 


    };
}